/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.cip.esymons.eventos.bc;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.cip.esymons.eventos.be.Ambiente;
import org.cip.esymons.eventos.be.Preevento;
import org.cip.esymons.eventos.be.ReservaAmbiente;
import org.cip.esymons.eventos.be.ServicioEquipo;
import org.cip.esymons.general.bc.ConfiguracionFacadeLocal;
import org.cip.esymons.general.bc.DepartamentoFacadeLocal;
import org.cip.esymons.general.bc.DireccionPersonaFacadeLocal;
import org.cip.esymons.general.bc.DistritoFacadeLocal;
import org.cip.esymons.general.bc.PersonaJuridicaFacadeLocal;
import org.cip.esymons.general.bc.PersonaNaturalFacadeLocal;
import org.cip.esymons.general.bc.ProvinciaFacadeLocal;
import org.cip.esymons.general.bc.TelefonoSolicitanteFacadeLocal;
import org.cip.esymons.general.bc.TipoZonaFacadeLocal;
import org.cip.esymons.general.bc.ViaFacadeLocal;
import org.cip.esymons.general.be.Configuracion;
import org.cip.esymons.general.be.Departamento;
import org.cip.esymons.general.be.DireccionPersona;
import org.cip.esymons.general.be.Distrito;
import org.cip.esymons.general.be.PersonaJuridica;
import org.cip.esymons.general.be.PersonaNatural;
import org.cip.esymons.general.be.Provincia;
import org.cip.esymons.general.be.TelefonoSolicitante;
import org.cip.esymons.general.be.TipoZona;
import org.cip.esymons.general.be.Via;

/**
 *
 * @author oscar
 */
public class ReservaAmbienteDelegate {

    ReservaAmbienteFacadeLocal local;
    PersonaJuridicaFacadeLocal localEmpresa;
    PersonaNaturalFacadeLocal localPersona;
    DepartamentoFacadeLocal localDepartamento;
    ProvinciaFacadeLocal localProvincia;
    DistritoFacadeLocal localDistrito;
    ViaFacadeLocal localVia;
    TipoZonaFacadeLocal localTipoZona;
    DireccionPersonaFacadeLocal localDireccion;
    TelefonoSolicitanteFacadeLocal localTelefono;
    ConfiguracionFacadeLocal localConfiguracion;

    public ReservaAmbienteDelegate() {
        local = lookupReservaAmbienteFacade();
        localEmpresa = lookupPersonaJuridicaFacade();
        localPersona = lookupPersonaNaturalFacade();
        localDepartamento = lookupDepartamentoFacade();
        localProvincia = lookupProvinciaFacade();
        localDistrito = lookupDistritoFacade();
        localVia  = lookupViaFacade();
        localTipoZona = lookupTipoZonaFacade();
        localDireccion = lookupDireccionPersonaFacade();
        localTelefono = lookupTelefonoSolicitanteFacade();
        localConfiguracion = lookupConfiguracionFacade();
    }

    public void eliminar(ReservaAmbiente res) throws Exception{
        local.remove(res);
    }

    public List<ReservaAmbiente> listarReservaPorEvento(Preevento preEventoSeleccionado) throws Exception{
        return local.listarAmbientesPorEvento(preEventoSeleccionado);
    }

    public List<ReservaAmbiente> listarReserva_Dia(Date fechaAmbiente,Ambiente ambiente) {
        try {
            return local.reserva_ambiente(fechaAmbiente,ambiente);
        } catch (Exception e) {

            return new ArrayList<ReservaAmbiente>();
        }
    }

    public List<ReservaAmbiente> listarReserva_Dia(Date fechaAmbiente, ServicioEquipo equipo) {
       try {
            return local.reserva_ambiente(fechaAmbiente,equipo);
        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
            return new ArrayList<ReservaAmbiente>();
        }
    }

    //lizardo was here
    public List<ReservaAmbiente> listarReserva_Dia(Date fechaAmbiente) {
       try {
            return local.reserva_ambiente(fechaAmbiente);
        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
            return new ArrayList<ReservaAmbiente>();
        }
    }

    //lizardo was here
    public List<ReservaAmbiente> listarReservas(Date fecha, Integer codigo, boolean tipo) throws Exception {
        return local.listarReservas(fecha, codigo, tipo);
    }

    public List<ReservaAmbiente> listarReservasXFecha(Date fecha,int horaInicio,int horaFin) {
        try {
            return local.reservasxfecha(fecha,horaInicio,horaFin);
        } catch (Exception e) {
            System.out.println("Error en: " + e.toString());
            System.out.println("Errorrrrrrr-------  " + e.toString());
            return new ArrayList<ReservaAmbiente>();
        }
    }

    public List<ReservaAmbiente> listarTodos() {
        try {
            return local.findAll();
        } catch (Exception e) {
            System.out.println("Error en: " + e.toString());
            return new ArrayList<ReservaAmbiente>();
        }
    }

    public void registrar(ReservaAmbiente res) {
        try {
            local.create(res);
        } catch (Exception e) {
            System.out.println("Error en: " + e.toString());
        }
    }

    public void registrarV2(ReservaAmbiente res) throws Exception {
        local.create(res);
    }

    public ReservaAmbiente buscar(Long id) {
        try {
            return local.find(id);
        } catch (Exception e) {
            return new ReservaAmbiente();
        }
    }

    //lizardo estuvo aqui
    public List<ReservaAmbiente> listarReservas(Integer conCodigo) throws Exception {
        return local.listarReservas(conCodigo);
    }

    //hecho por lizardo
    public List<ReservaAmbienteAgrupadaAdapter> listarReservaAmbientesAgrupadas (Integer conCodigo) throws Exception {
        return local.listarReservaAmbientesAgrupadas(conCodigo);
    }

    //hecho por lizardo
    public List<ReservaAmbienteAgrupadaAdapter> listarReservaServiciosAgrupadas(Integer conCodigo) throws Exception {
        return local.listarReservaServiciosAgrupadas(conCodigo);
    }

    private ReservaAmbienteFacadeLocal lookupReservaAmbienteFacade() {
        try {
            Context c = new InitialContext();
            return (ReservaAmbienteFacadeLocal) c.lookup("java:comp/env/ReservaAmbienteFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public PersonaJuridica buscaRazonSocial(String razon) throws Exception {
        return localEmpresa.buscaJuridicaPorRazonSocial(razon);
    }

    public List<PersonaJuridica> listaRazonSocial(String razon) throws Exception {
        return localEmpresa.buscaJuridicaPorRazonSocial2(razon);
    }

    public PersonaJuridica buscaRuc(String ruc) throws Exception {
        return localEmpresa.buscaJuridicaPorRuc(ruc);
    }

    public PersonaJuridica buscaRucV2(String ruc) throws Exception {
        return localEmpresa.buscaJuridicaPorRucV2(ruc);
    }

    public PersonaJuridica encontrarEmpresa(Long solCodigo) throws Exception {
        return localEmpresa.find(solCodigo);
    }

    public void registrarEmpresa(PersonaJuridica empresa) throws Exception {
        localEmpresa.create(empresa);
    }

    private PersonaJuridicaFacadeLocal lookupPersonaJuridicaFacade() {
        try {
            Context c = new InitialContext();
            return (PersonaJuridicaFacadeLocal) c.lookup("java:comp/env/PersonaJuridicaFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public PersonaNatural buscarDni(String dni) throws Exception {
        return localPersona.buscarXDni1(dni);
    }

    public List<PersonaNatural> buscarPersona(String paterno, String materno, String nombres) throws Exception {
        return localPersona.buscarXApellidosyNombres(paterno, materno, nombres);
    }

    public PersonaNatural encontrarPersona(Long solCodigo) throws Exception {
        return localPersona.find(solCodigo);
    }

    public void registrarPersona(PersonaNatural persona) throws Exception {
        localPersona.create(persona);
    }

    private PersonaNaturalFacadeLocal lookupPersonaNaturalFacade() {
        try {
            Context c = new InitialContext();
            return (PersonaNaturalFacadeLocal) c.lookup("java:comp/env/PersonaNaturalFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }
    
    public List<Departamento> listarDepartamentos() throws Exception {
        return localDepartamento.findAll();
    }

    public Departamento buscarDepartamento(Integer codDepartamento) throws Exception {
        return localDepartamento.find(codDepartamento);
    }

    private DepartamentoFacadeLocal lookupDepartamentoFacade() {
        try {
            Context c = new InitialContext();
            return (DepartamentoFacadeLocal) c.lookup("java:comp/env/DepartamentoFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public List<Provincia> listarProvincias(Departamento dpto) throws Exception {
        return localProvincia.listaPorDpto(dpto);
    }

    public Provincia buscarProvincia(Integer codProvincia) throws Exception {
        return localProvincia.find(codProvincia);
    }

    private ProvinciaFacadeLocal lookupProvinciaFacade() {
        try {
            Context c = new InitialContext();
            return (ProvinciaFacadeLocal) c.lookup("java:comp/env/ProvinciaFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public List<Distrito> listarDistritos(Provincia prov) throws Exception {
        return localDistrito.listaPorProvincia(prov);
    }

    public Distrito buscarDistrito(Integer codDistrito) throws Exception {
        return localDistrito.find(codDistrito);
    }

    private DistritoFacadeLocal lookupDistritoFacade() {
        try {
            Context c = new InitialContext();
            return (DistritoFacadeLocal) c.lookup("java:comp/env/DistritoFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public List<Via> listarVias() throws Exception {
        return localVia.findAll();
    }

    public Via buscarVia(Integer codVia) throws Exception {
        return localVia.find(codVia);
    }

    private ViaFacadeLocal lookupViaFacade() {
        try {
            Context c = new InitialContext();
            return (ViaFacadeLocal) c.lookup("java:comp/env/ViaFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public List<TipoZona> listarZonas() throws Exception {
        return localTipoZona.findAll();
    }

    public TipoZona buscarZona(Integer codZona) throws Exception {
        return localTipoZona.find(codZona);
    }

    private TipoZonaFacadeLocal lookupTipoZonaFacade() {
        try {
            Context c = new InitialContext();
            return (TipoZonaFacadeLocal) c.lookup("java:comp/env/TipoZonaFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public void registrarDireccion(DireccionPersona direccion) throws Exception {
        localDireccion.create(direccion);
    }

    public DireccionPersona encontrarDireccionActivo(Long solCodigo) throws Exception {
        return localDireccion.buscaDireccionColegiado(solCodigo);
    }

    public void eliminarDireccion(DireccionPersona direccion) throws Exception {
        localDireccion.remove(direccion);
    }

    public List<DireccionPersona> listarDireccion(Long solCodigo) throws Exception {
        return localDireccion.listarDireccionxSolicitante(solCodigo);
    }

    private DireccionPersonaFacadeLocal lookupDireccionPersonaFacade() {
        try {
            Context c = new InitialContext();
            return (DireccionPersonaFacadeLocal) c.lookup("java:comp/env/DireccionPersonaFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public void registrarTelefono(TelefonoSolicitante telefono) throws Exception {
        localTelefono.create(telefono);
    }

    public List<TelefonoSolicitante> listarTelefonos(Long solCodigo) throws Exception {
        return localTelefono.listaTelefonoColegiado(solCodigo);
    }

    private TelefonoSolicitanteFacadeLocal lookupTelefonoSolicitanteFacade() {
        try {
            Context c = new InitialContext();
            return (TelefonoSolicitanteFacadeLocal) c.lookup("java:comp/env/TelefonoSolicitanteFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public Configuracion configuracionActiva(Integer plataforma) throws Exception {
        return localConfiguracion.findActive(plataforma);
    }

    private ConfiguracionFacadeLocal lookupConfiguracionFacade() {
        try {
            Context c = new InitialContext();
            return (ConfiguracionFacadeLocal) c.lookup("java:comp/env/ConfiguracionFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }


}
